import { get, post, uploadFile } from '@/service/request.js'
import { userStore } from '@/utils/userStore.js'
// 用户相关接口
export const userApi = {
	
  weixinCode: async()=> {
	try {
		// // 调用微信登录
		// const { code } = await uni.login({
		//     provider: 'weixin'
		// });
		// if (!code) {
		//     throw new Error('微信登录失败');
		// }	
		// // 调用登录接口
		// const loginResult = await userApi.wxLogin(code)
	
		const loginResult = await userApi.wxLogin('xiaowen_53')
		console.log(loginResult)
		userStore.saveUserInfo(loginResult)
		return loginResult
		
	} catch (error) {
		uni.showToast({
			title: error.message || '登录失败',
			icon: 'none'
		})
	}
  },
  // wx_stable_token: (code) => {
  //   return new Promise((resolve, reject) => {
  //     uni.request({
  //       url: 'https://api.weixin.qq.com/cgi-bin/stable_token',
  //       method: "POST",
  //       data: {
  //         grant_type: 'client_credential',
  //         appid: 'wx26948a03e797cf05',
  //         secret: '610cce86c61251026f8b90be9d99a415'
  //       },
  //       success: async (res) => {
  //         try {
  //           // 获取到 token 后直调用获取手机号接口
  //           const phoneNumber = await userApi.wx_getPhone(res.data.access_token, code)
  //           resolve(phoneNumber)
  //         } catch (error) {
  //           reject(error)
  //         }
  //       },
  //       fail: (err) => {
  //         console.error("获取token失败=>", err)
  //         reject(new Error('获取access_token失败'))
  //       }
  //     })
  //   })
  // },

  // // 获取手机号
  // wx_getPhone: (token, code) => {
  //   return new Promise((resolve, reject) => {
  //     uni.request({
  //       url: `https://api.weixin.qq.com/wxa/business/getuserphonenumber?access_token=${token}`,
  //       method: "POST",
  //       data: {
  //         code: code
  //       },
  //       success: (res) => {
  //         console.log("获取到的用户手机号信息：", res)
          
  //         if (res.data && res.data.phone_info && res.data.phone_info.purePhoneNumber) {
  //           resolve(res.data.phone_info.purePhoneNumber)
  //         } else {
  //           reject(new Error('获取手机号失败：返回数据格式错误'))
  //         }
  //       },
  //       fail: (err) => {
  //         console.error("获取手机号失败", err)
  //         reject(new Error('获取手机号失败'))
  //       }
  //     })
  //   })
  // },

  /**
   * 微信小程序登录
   * @param {string} code 微信认证code
   * @returns {Promise} 返回登录信息和token
   */
  wxLogin: (code) => {
    return get('/api/login/weixin', { code})
  },

  /**
   * 获取当前用户信息
   * @returns {Promise} 返回用户信息
   */
  getUserInfo: () => {
    return get('/api/userinfo')
  },

  /**
   * 提交用户昵称和头像
   * @param {string} name 用户昵称
   * @param {string} avator 用户头像
   * @returns {Promise} 返回更新后的用户信息
   */
  updateAvator: (name, avator) => {
    return get('/api/userinfo/avator', { name, avator })
  },

  /**
   * 提交用户手机号
   * @param {string} phone 手机号
   * @returns {Promise} 返回更新后的用户信息
   */
  updatePhone: (phoneWxCode) => {
    return get('/api/userinfo/phone', { phoneWxCode })
  },

  /**
   * 提交用户身份
   * @param {string} type 用户身份 ('gas' | 'maintenance' | 'supplier' | 'client')
   * @returns {Promise} 返回更新后的用户信息
   */
  updateUserType: (type) => {
    return get('/api/userinfo/user-type', { type })
  },

  /**
   * 完善用户信息（加油站和维修商通用）
   * @param {Object} userInfo 用户信息对象
   * @param {Object} images 用户图片对象
   * @returns {Promise} 返回更新后的用户信息
   */
  commitUserInfo: (userInfo, images) => {
    return post('/api/userinfo/commit-userinfo', {
      userInfo,
      images
    })
  }
}

// 文件相关接口
export const fileApi = {
  /**
   * 上传单个文件
   * @param {string} filePath 文件路径
   * @returns {Promise<string>} 返回文件URL
   */
  uploadSingle: async (filePath) => {
    return await uploadFile(filePath)
  },

  /**
   * 批量上传文件
   * @param {string[]} filePaths 文件路径数组
   * @returns {Promise<string[]>} 返回文件URL数组
   */
  uploadMultiple: async (filePaths) => {
    const promises = filePaths.map(path => uploadFile(path))
    return await Promise.all(promises)
  }
}


// 组织相关接口
export const orgApi = {
  /**
   * 检查组织名称是否存在
   * @param {string} name 组织名称
   * @returns {Promise<boolean>} 返回是否存在
   */
  checkOrgNameExist: (name) => {
    return get('/api/org/exist-org', { name })
  },

  /**
   * 创建组织
   * @param {Object} orgData 组织信息
   * @returns {Promise<Object>} 返回组织详情
   */
  createOrg: (orgData) => {
    return post('/api/org/create-org', orgData)
  },

  /**
   * 通过组织代码查找组织
   * @param {string} codeNo 组织代码
   * @returns {Promise<Object>} 返回组织简要信息
   */
  findOrgByCode: (codeNo) => {
    return get('/api/org/find-org', { codeNo })
  },

  /**
   * 加入组织
   * @param {string} codeNo 组织代码
   * @returns {Promise<Object>} 返回成员信息
   */
  joinOrg: (codeNo) => {
    return get('/api/org/join-org', { codeNo })
  },

  /**
   * 获取组织详情
   * @param {string} orgId 组织ID
   * @returns {Promise<Object>} 返回组织详情
   */
  getOrgDetail: (orgId) => {
    return get('/api/org/org-detail', { orgId })
  },

  /**
   * 更新组织信息
   * @param {Object} orgData 组织信息
   * @returns {Promise<Object>} 返回更新后的组织详情
   */
  updateOrg: (orgData) => {
    return post('/api/org/update-org', orgData)
  },
  // 获取品牌列表
  getBrandList() {
  	return get('/api/config/branch', {})
  }
}

// 组织员相关接口
export const memberApi = {
  /**
   * 获取组织成员列表
   * @param {string} orgId 组织ID
   * @returns {Promise<Object>} 返回成员列表
   */
  getMemberList: (orgId) => {
    return get('/api/members/list', { orgId })
  },

  /**
   * 获取成员详情
   * @param {string} memberId 成员ID
   * @returns {Promise<Object>} 返回成员详情
   */
  getMemberDetail: (memberId) => {
    return get('/api/members/member-detail', { memberId })
  },

  /**
   * 审核成员
   * @param {string} memberId 成员ID
   * @param {boolean} accepted 是否通过
   * @param {MEMBER_ROLES} [role] 可选的组织角色
   * @returns {Promise<Object>} 返回成员信息
   */
  reviewMember: (memberId, accepted, role) => {
    return get('/api/members/accept-member', { memberId, accepted, role })
  },

  /**
   * 更改成员角色
   * @param {string} memberId 成员ID
   * @param {MEMBER_ROLES} role 组织角色
   * @returns {Promise<Object>} 返回成员信息
   */
  changeMemberRole: (memberId, role) => {
    return get('/api/members/change-member-role', { memberId, role })
  },

  /**
   * 删除成员
   * @param {string} memberId 成员ID
   * @returns {Promise<void>}
   */
  deleteMember: (memberId) => {
    return get('/api/members/remove-member', { memberId })
  }
}


// 用户身份常量
export const USER_TYPES = {
  GAS: 'gas',           // 加油站
  MAINTENANCE: 'maintenance', // 维护提供商
  SUPPLIER: 'supplier',     // 设备提供商
  CLIENT: 'client'         // 行业用户
}

// 证书类型常量
export const CERT_TYPES = {
  EXPLOSION_PROOF: 'main_cert_1',  // 防爆合格证
  ELECTRICIAN: 'main_cert_2',      // 电工证
  MEASUREMENT: 'main_cert_3',      // 计量证
  GVR_TRAINING: 'main_cert_4',     // GVR培训证
  OIL_TRAINING: 'main_cert_5'      // 石油公司培训证
}

// 组织角色常量
export const MEMBER_ROLES = {
  DIRECTOR: 'director',  // 管理员、站长
  MANAGER: 'manager',    // 主管
  STAFF: 'staff'        // 职工、维修员
}
//审核状态
export const EXAMINE_STATUS = {
  DISABLED: 'disabled',  // 未启用
  ENABLED: 'enabled',    //启用
  VERIFYING: 'verifying' ,// 审核中
  REFUSED:'refused'//驳回
}

// 组织角色显示名称
export const MEMBER_ROLE_NAMES = {
  [MEMBER_ROLES.DIRECTOR]: '站长',
  [MEMBER_ROLES.MANAGER]: '主管',
  [MEMBER_ROLES.STAFF]: '员工'
}

// 组织角色显示名称
export const MEMBER_REPAIER_ROLE_NAMES = {
  [MEMBER_ROLES.DIRECTOR]: '站长',
  [MEMBER_ROLES.MANAGER]: '维修主管',
  [MEMBER_ROLES.STAFF]: '维修员'
}

// 性别名称显示
export const MEMBER_GENDER_NAMES = {
  '1': '男',
  '2': '女',
  '3': '保密'
}


// 资质认证映射关系
export const QUALIFICATION_MEMBER_MAP = {
  main_cert_1: '防爆合格证',
  main_cert_2: '电工证',
  main_cert_3: '计量证',
  main_cert_4: 'GVR培训证',
  main_cert_5: '石油公司培训证'
}
// 定义固定的资质列表顺序
export const QUALIFICATION_MEMBER_ORDER = [
  'main_cert_1',
  'main_cert_2',
  'main_cert_3',
  'main_cert_4',
  'main_cert_5',
]





// 关系类型常量
export const RELATION_TYPES = {
  CONTRACT: 'contract',    // 合作关系
  COLLECTION: 'collection' // 收藏关系
}

// 收藏与合作关系相关接口
export const relationApi = {
  /**
   * 获取当前合作的维修商列表
   * @returns {Promise<Array>} 返回合作维修商列表
   */
  getContractList: () => {
    return get('/api/relation/contract')
  },

  /**
   * 获取收藏/合作/全部的维修商列表
   * @returns {Promise<Object>} 返回包含三种列表的对象
   */
  getRelationList: () => {
    return get('/api/relation/get-list')
  },
 /**
   * 收藏/合作维修商
   * @param {string} orgId 维修商id
   * @param {RELATION_TYPES} type 关系类型
   * @returns {Promise<Object>} 返回操作结果
   */
  connect: (orgId, type) => {
    if (!Object.values(RELATION_TYPES).includes(type)) {
	  return Promise.reject(new Error('Invalid relation type'))
    }
    return get('/api/relation/connect', { orgId, type })
  },

  /**
   * 取消收藏/合作维修商
   * @param {string} relationId 关系id
   * @returns {Promise<Object>} 返回操作结果
   */
  disconnect: (relationId) => {
    return get('/api/relation/disconnect', { relationId })
  }
}

// 维修单状态常量
export const TASK_STATUS = {
  ASSIGNING: 'assigning',   // 待派单
  WAITING: 'waiting',       // 待接单
  STANDBY: 'standby',       // 已接单
  ONWAY: 'onway',          // 上站中
  REPAIRING: 'repairing',   // 维修中
  CHECKING: 'checking',     // 待验收
  EVALUATING: 'evaluating', // 待评价
  FINISHING: 'finishing',   // 已完成
  CANCEL: 'cancel'         // 已取消
}

// 维修单类型常量
export const TASK_TYPES = {
  REPAIR: 'repair',     // 维修
  UPGRADE: 'upgrade',   // 改造升级
  INSPECT: 'inspect',   // 巡视
  INSTALL: 'install',   // 安装
  OTHERS: 'others'      // 其它
}

// 维修单分类常量
export const TASK_CATEGORIES = {
  ALL: '0',        // 全部
  ASSIGNING: '1',  // 待派单
  WAITING: '2',    // 待维修
  FINISHED: '3',   // 已完成
  CANCELED: '4'    // 已取消
}

// 维修单相关接口
export const taskApi = {
  /**
   * 获取维修单数量统计
   * @returns {Promise<Object>} 返回维修单统计数据
   */
  getTaskStats: () => {
    return get('/api/task/stat')
  },

  /**
   * 获取维修单列表
   * @param {Object} params 查询参数
   * @param {string} params.category 维修单分类
   * @param {string} [params.startTime] 起始时间
   * @param {string} [params.stopTime] 结束时间
   * @param {number} [params.page=1] 页码
   * @param {number} [params.size=10] 每页条数
   * @returns {Promise<Object>} 返回维修单列表数据
   */
  getTaskList: (params) => {
    return get('/api/task/list', params)
  },

  /**
   * 获取维修单详情
   * @param {string} taskId 维修单id
   * @returns {Promise<Object>} 返回维修单详情
   */
  getTaskDetail: (taskId) => {
    return get('/api/task/detail', { taskId })
  },

  /**
   * 创建维修单
   * @param {Object} taskData 维修单数据
   * @returns {Promise<Object>} 返回创建的维修单
   */
  createTask: (taskData) => {
    return post('/api/task/create', taskData)
  },

  /**
   * 取消维修单
   * @param {string} taskId 维修单id
   * @returns {Promise<Object>} 返回操作结果
   */
  cancelTask: (taskId) => {
    return post('/api/task/action/cancel', { taskId })
  },

  /**
   * 修改维修单
   * @param {Object} taskData 维修单数据
   * @returns {Promise<Object>} 返回修改后的维修单
   */
  modifyTask: (taskData) => {
    return post('/api/task/action/modify', taskData)
  },

  /**
   * 评价维修单
   * @param {string} taskId 维修单id
   * @param {number} rating 评分(0-100)
   * @returns {Promise<Object>} 返回操作结果
   */
  evaluateTask: (taskId, rating) => {
    return post('/api/task/action/evaluate', { taskId, rating })
  },

  /**
   * 删除维修单
   * @param {string} taskId 维修单id
   * @returns {Promise<Object>} 返回操作结果
   */
  removeTask: (taskId) => {
    return post('/api/task/action/remove', { taskId })
  },

  /**
   * 验收维修单
   * @param {string} taskId 维修单id
   * @param {string} sign 站长签名图片
   * @returns {Promise<Object>} 返回操作结果
   */
  signTask: (taskId, sign) => {
    return post('/api/task/action/sign', { taskId, sign })
  },

  /**
   * 向公司成员派单
   * @param {string} taskId 维修单id
   * @param {string[]} memberIds 成员id数组
   * @returns {Promise<Object>} 返回操作结果
   */
  assignTask: (taskId, memberIds) => {
    return post('/api/task/action/assign', { taskId, memberIds })
  },

  /**
   * 维修员接单
   * @param {string} ticketId 派遣单id
   * @returns {Promise<Object>} 返回操作结果
   */
  acceptTask: (ticketId) => {
    return post('/api/task/action/accept', { ticketId })
  },

  /**
   * 维修员驳回派遣单
   * @param {string} ticketId 派遣单id
   * @returns {Promise<Object>} 返回操作结果
   */
  refuseTask: (ticketId) => {
    return post('/api/task/action/refuse', { ticketId })
  },

  /**
   * 维修员申请改派
   * @param {string} ticketId 派遣单id
   * @returns {Promise<Object>} 返回操作结果
   */
  reassignTask: (ticketId) => {
    return post('/api/task/action/reassign', { ticketId })
  },

  /**
   * 维修员出发上站
   * @param {string} ticketId 派遣单id
   * @returns {Promise<Object>} 返回操作结果
   */
  departTask: (ticketId) => {
    return post('/api/task/action/depart', { ticketId })
  },

  /**
   * 维修员到站
   * @param {string} ticketId 派遣单id
   * @returns {Promise<Object>} 返回操作结果
   */
  arriveTask: (ticketId) => {
    return post('/api/task/action/arrive', { ticketId })
  },

  /**
   * 维修员处理维修单
   * @param {Object} params 处理参数
   * @param {boolean} params.commit 是否提交验收
   * @param {string} params.ticketId 派遣单id
   * @param {string} params.type 维修单类型
   * @param {string} params.faultyPart 实际故障部件
   * @param {string} params.falutyCodeNo 实际故障部件设备号
   * @param {string} params.reason 故障原因
   * @param {string} params.measure 维修措施
   * @param {boolean} params.warranty 是否在保
   * @param {string[]} params.images 维修图片数组
   * @param {Object[]} params.bills 报价账单数组
   * @returns {Promise<Object>} 返回操作结果
   */
  dowork: (params) => {
    return post('/api/task/action/dowork', params)
  }
}

// 位置相关接口
export const positionApi = {
  /**
   * 获取维修单的员工实时位置
   * @param {string} taskId 维修单id
   * @returns {Promise<Object>} 返回员工位置信息
   */
  queryPosition: (taskId) => {
    return get('/api/position/query', { taskId })
  },

  /**
   * 维修员工提交实时位置
   * @param {string} taskId 维修单id
   * @param {Object} location 位置信息
   * @param {number} location.lon 经度
   * @param {number} location.lat 纬度
   * @returns {Promise<Object>} 返回操作结果
   */
  commitPosition: (taskId, location) => {
    return post('/api/position/commit', { taskId, location })
  }
}